/**
 * PLM项目Store安全包装器
 * 使用MobX辅助工具处理状态更新的安全问题
 */

// 导入原始store
let originalStore;
try {
  originalStore = require('./plm_project_store.js');
  console.log('成功加载原始PLM项目Store');
} catch (e) {
  console.error('加载原始PLM项目Store失败，使用模拟实现', e);
  // 提供模拟实现
  originalStore = {
    loading: false,
    error: null,
    projectList: [],
    pagination: { page: 1, size: 20, total: 0, hasMore: true },
    formatProject: (project) => {
      // 确保项目对象存在
      if (!project) {
        console.warn('formatProject: 项目数据为空，返回默认项目');
        return {
          _id: 'default-' + Date.now(),
          model: '默认项目',
          cate: '其他',
          status: 0,
          devManager: '未知',
          bizManager: '未知',
          createTime: Math.floor(Date.now() / 1000),
          updateTime: Math.floor(Date.now() / 1000),
          description: '暂无描述',
          progress: 0,
          priority: 'normal'
        };
      }
      
      // 确保关键字段存在
      const safeProject = {
        ...project,
        _id: project._id || ('default-' + Date.now()),
        model: project.model || '未命名项目',
        cate: project.cate || '其他',
        status: typeof project.status === 'number' ? project.status : 0,
        progress: typeof project.progress === 'number' ? project.progress : 0,
        createTime: project.createTime || Math.floor(Date.now() / 1000),
        updateTime: project.updateTime || Math.floor(Date.now() / 1000)
      };
      
      return safeProject;
    },
    filters: {}
  };
}

// 改进formatProject方法，确保更好地处理空数据和异常情况
if (originalStore.formatProject) {
  const originalFormatProject = originalStore.formatProject;
  originalStore.formatProject = function(project) {
    // 确保项目对象存在，处理null、undefined或非对象
    if (!project || typeof project !== 'object') {
      console.warn('formatProject: 项目数据无效, 类型:', typeof project);
      return {
        _id: 'default-' + Date.now(),
        model: '默认项目',
        cate: '其他',
        status: 0,
        devManager: '未知',
        bizManager: '未知',
        createTime: Math.floor(Date.now() / 1000),
        updateTime: Math.floor(Date.now() / 1000),
        description: '暂无描述',
        progress: 0,
        priority: 'normal'
      };
    }
    
    // 直接提供getStatusText方法的引用，避免this上下文问题
    if (!originalStore.getStatusText) {
      console.warn('getStatusText方法不存在，添加实现');
      originalStore.getStatusText = function(status) {
        const statusMap = {
          0: '草稿',
          1: '待立项',
          2: '已立项',
          3: '设计中',
          4: '开发中',
          5: '测试中',
          6: '已完成',
          99: '已取消'
        };
        return statusMap[status] || '未知状态';
      };
    }
    
    // 先提取getStatusText方法，避免依赖this
    const getStatusText = originalStore.getStatusText.bind(originalStore);
    
    // 检查是否需要引入研发状态机
    if ((project.status >= 10 || typeof project.status === 'string') && !originalStore.getResearchStatusText) {
      console.log('检测到研发状态需要加载状态机');
      try {
        // 首先尝试从模块配置获取研发状态机
        let researchStateBiz;
        try {
          // 使用正确的路径解析方法
          const pathResolver = require('../config/path_resolver.js');
          const moduleConfig = require('../config/module_config.js');
          if (moduleConfig && moduleConfig.researchStateBiz) {
            console.log('成功从模块配置获取研发状态机');
            researchStateBiz = moduleConfig.researchStateBiz;
          } else {
            throw new Error('模块配置中未找到researchStateBiz');
          }
        } catch (configError) {
          console.warn('从模块配置获取研发状态机失败，尝试直接加载:', configError);
          // 备用方案: 直接加载
          researchStateBiz = require('../biz/research_state_biz.js');
          console.log('成功直接加载研发状态机');
        }
        
        originalStore.getResearchStatusText = function(status, subStatus) {
          return researchStateBiz.getStatusName(status) || '未知研发状态';
        };
        console.log('成功加载研发状态机');
      } catch (e) {
        console.warn('加载研发状态机失败，使用简化状态文本', e);
        originalStore.getResearchStatusText = function(status) {
          return `研发状态${status}`;
        };
      }
    }
    
    // 调用原始方法
    try {
      // 明确绑定this上下文到originalStore
      const formattedProject = originalFormatProject.call(originalStore, project);
      
      // 二次安全检查，确保关键字段存在
      return {
        ...formattedProject,
        _id: formattedProject._id || ('default-' + Date.now()),
        model: formattedProject.model || '未命名项目',
        cate: formattedProject.cate || '其他',
        status: typeof formattedProject.status === 'number' ? formattedProject.status : 0,
        progress: typeof formattedProject.progress === 'number' ? formattedProject.progress : 0,
        createTime: formattedProject.createTime || Math.floor(Date.now() / 1000),
        updateTime: formattedProject.updateTime || Math.floor(Date.now() / 1000),
        description: formattedProject.description || '暂无描述',
        statusText: formattedProject.statusText || getStatusText(project.status)
      };
    } catch (error) {
      console.error('formatProject执行失败，返回安全默认值:', error);
      // 出错时返回安全的默认值
      return {
        _id: project._id || ('default-' + Date.now()),
        model: project.model || '未命名项目',
        cate: project.cate || '其他',
        status: typeof project.status === 'number' ? project.status : 0,
        devManager: project.devManager || '未知',
        bizManager: project.bizManager || '未知',
        createTime: project.createTime || Math.floor(Date.now() / 1000),
        updateTime: project.updateTime || Math.floor(Date.now() / 1000),
        description: project.description || '暂无描述',
        progress: typeof project.progress === 'number' ? project.progress : 0,
        statusText: project.statusText || getStatusText(project.status)
      };
    }
  };
}

// 导入MobX配置工具
let mobxTools;
try {
  mobxTools = require('./helpers/mobx_config.js');
  console.log('成功加载MobX配置工具');
} catch (e) {
  console.error('加载MobX配置工具失败，使用简易实现', e);
  // 提供简易实现
  mobxTools = {
    createSafeAction: (fn) => fn,
    safeSet: (target, prop, value) => { target[prop] = value; }
  };
}

// 预先定义错误处理器和页面助手，防止undefined错误
let errorHandler = {
  handleMobxError: (error, actionName) => {
    console.error(`MobX错误 [${actionName}]:`, error);
    wx.showToast({
      title: '操作失败，请重试',
      icon: 'none'
    });
  },
  logError: (module, error) => {
    console.error(`[${module}] 错误:`, error);
  }
};

// 预先定义页面助手
let pageHelper = {
  get: (key) => null,
  set: (key, val, time) => {},
  remove: (key) => {},
  removePrefix: (prefix) => {},
  handleMobxError: errorHandler.handleMobxError,
  callCloudData: async (url, data, options) => {
    console.warn('callCloudData使用模拟实现');
    try {
      // 使用模拟数据服务来代替实际的API调用
      const mockService = require('../config/services_config.js').plmMockService;
      if (!mockService) {
        throw new Error('模拟数据服务未加载');
      }
      
      if (url === 'plm/project_list') {
        return mockService.getProjectList(data);
      } else if (url === 'plm/project_detail') {
        return mockService.getProjectDetail(data.id);
      } else {
        return { code: -1, msg: '不支持的API: ' + url };
      }
    } catch (e) {
      console.error('模拟数据服务调用失败:', e);
      return { code: -1, msg: '请求失败', error: e.message };
    }
  }
};

// 导入模拟数据服务（用于网络错误时的备用数据）
let mockService;
try {
  // 使用正确的路径直接引用模拟数据服务
  mockService = require('../config/services_config.js').plmMockService;
  console.log('成功加载PLM项目模拟数据服务');
  
  // 包装模拟服务方法，确保数据结构完整
  const originalGetProjectList = mockService.getProjectList;
  mockService.getProjectList = function(params) {
    try {
      const result = originalGetProjectList(params);
      
      // 验证结果结构
      if (!result) {
        throw new Error('模拟服务返回空结果');
      }
      
      // 确保结果有必要的属性
      return {
        code: 0,
        msg: 'ok',
        list: Array.isArray(result.list) ? result.list : [],
        total: typeof result.total === 'number' ? result.total : 0,
        page: params.page || 1,
        size: params.size || 20
      };
    } catch (error) {
      console.warn('模拟服务getProjectList失败，返回安全的空结果:', error);
      // 返回安全的空结果
      return {
        code: 0,
        msg: 'mock data (fallback)',
        list: [],
        total: 0,
        page: params.page || 1,
        size: params.size || 20
      };
    }
  };

  // 增强getProjectDetail方法，确保始终返回有效项目数据
  const originalGetProjectDetail = mockService.getProjectDetail;
  mockService.getProjectDetail = function(id) {
    try {
      console.log('[模拟数据服务] 尝试获取项目详情, ID:', id);
      
      // 尝试调用原始方法
      const result = originalGetProjectDetail(id);
      
      // 验证返回数据结构
      if (!result || !result.data) {
        console.warn('[模拟数据服务] 原始getProjectDetail返回无效数据，使用备用数据');
        throw new Error('模拟服务返回结构不完整');
      }
      
      // 确保数据具有所有必要字段
      const projectData = result.data;
      if (!projectData._id || !projectData.model) {
        console.warn('[模拟数据服务] 项目数据缺少关键字段，进行补充');
      }
      
      // 确保参数字段正确映射
      console.log('[模拟数据服务] 检查并补充参数字段映射');
      
      // 生成完整的项目数据（如果原数据缺失字段则提供默认值）
      const completeProject = {
        _id: projectData._id || id || 'mock_' + Date.now(),
        model: projectData.model || `项目${id || 'Unknown'}`,
        cate: projectData.cate || '默认分类',
        status: typeof projectData.status === 'number' ? projectData.status : 2, // 默认"已立项"
        devManager: projectData.devManager || '研发负责人',
        bizManager: projectData.bizManager || '业务负责人',
        createTime: projectData.createTime || Math.floor(Date.now() / 1000 - 86400), // 默认一天前
        updateTime: projectData.updateTime || Math.floor(Date.now() / 1000),
        description: projectData.description || '这是项目的详细描述。包含项目信息、进度、和相关业务需求。',
        progress: typeof projectData.progress === 'number' ? projectData.progress : 30,
        priority: projectData.priority || 'normal',
        // 添加更多可能需要的字段...
        requirementDocs: projectData.requirementDocs || [],
        members: projectData.members || [],
        
        // 项目参数字段
        WORK_TEMP: projectData.WORK_TEMP || '未设置',
        CERTIFICATION: projectData.CERTIFICATION || '无',
        LOW_POWER: projectData.LOW_POWER || '无',
        STARTUP_TIME: projectData.STARTUP_TIME || '未设置',
        CONFORMAL_COATING: projectData.CONFORMAL_COATING || '无',
        RATED_VOLTAGE: projectData.RATED_VOLTAGE || '未设置',
        MAX_POWER: projectData.MAX_POWER || '未设置',
        MAX_SPEED: projectData.MAX_SPEED || '未设置',
        POLE_PAIRS: projectData.POLE_PAIRS || '未设置',
        HAS_HALL: projectData.HAS_HALL || '未设置',
        CONTROL_MODE: projectData.CONTROL_MODE || '未设置',
        CONTROL_ALGORITHM: projectData.CONTROL_ALGORITHM || '未设置',
        
        // 保护参数
        STALL_PROTECTION: projectData.STALL_PROTECTION || '无',
        OVERVOLTAGE_PROTECTION: projectData.OVERVOLTAGE_PROTECTION || '无',
        UNDERVOLTAGE_PROTECTION: projectData.UNDERVOLTAGE_PROTECTION || '无',
        TEMPERATURE_PROTECTION: projectData.TEMPERATURE_PROTECTION || '无',
        OVERCURRENT_PROTECTION: projectData.OVERCURRENT_PROTECTION || '无',
        
        // 控制方式参数
        CONTROL_INTERFACE: projectData.CONTROL_INTERFACE || projectData.CONTROL_MODE || '未设置',
        
        // 项目类型名称 (用于控制显示逻辑)
        PROJECT_TYPE_NAME: projectData.PROJECT_TYPE_NAME || projectData.cate || '默认分类'
      };
      
      console.log('[模拟数据服务] 成功生成项目详情:', completeProject.model);
      
      return {
        code: 0,
        msg: 'ok',
        data: completeProject
      };
    } catch (error) {
      console.warn('[模拟数据服务] getProjectDetail出错，返回完全模拟的数据:', error);
      
      // 返回安全的备用项目数据（无论发生什么错误）
      const safeProject = {
        _id: id || 'mock_' + Date.now(),
        model: `项目${id || 'Unknown'}`,
        cate: '默认分类',
        status: 2,  // "已立项"
        devManager: '研发负责人',
        bizManager: '业务负责人',
        createTime: Math.floor(Date.now() / 1000 - 86400), // 一天前
        updateTime: Math.floor(Date.now() / 1000),
        description: '这是通过模拟生成的项目详情。实际项目数据获取失败，使用备用数据显示。',
        progress: 30,
        priority: 'normal',
        requirementDocs: [],
        members: [],
        
        // 项目参数字段
        WORK_TEMP: '-40~85',
        CERTIFICATION: 'ISO 9001',
        LOW_POWER: '20',
        STARTUP_TIME: '1.0',
        CONFORMAL_COATING: '标准三防漆',
        RATED_VOLTAGE: '12',
        MAX_POWER: '0.8',
        MAX_SPEED: '5000',
        POLE_PAIRS: '24',
        HAS_HALL: '标准配置',
        CONTROL_MODE: 'PWM控制',
        CONTROL_ALGORITHM: 'PID',
        
        // 保护参数
        STALL_PROTECTION: '支持',
        OVERVOLTAGE_PROTECTION: '15V',
        UNDERVOLTAGE_PROTECTION: '9V',
        TEMPERATURE_PROTECTION: '90℃',
        OVERCURRENT_PROTECTION: '150A',
        
        // 控制方式参数
        CONTROL_INTERFACE: 'PWM控制',
        
        // 项目类型
        PROJECT_TYPE_NAME: '电流传感器'
      };
      
      console.log('[模拟数据服务] 返回备用项目数据:', safeProject.model);
      
      return {
        code: 0,
        msg: 'ok (fallback)',
        data: safeProject
      };
    }
  };
} catch (e) {
  console.error('加载PLM项目模拟数据服务失败，将使用简易模拟数据', e);
  // 提供简易模拟数据
  mockService = {
    getProjectList: (params) => ({
      code: 0,
      msg: 'ok',
      list: [
        {
          _id: 'mock1',
          model: '模拟项目1',
          status: 1,
          devManager: '张工',
          createTime: Math.floor(Date.now() / 1000) - 86400,
          progress: 10
        },
        {
          _id: 'mock2',
          model: '模拟项目2',
          status: 2,
          devManager: '李工',
          createTime: Math.floor(Date.now() / 1000) - 86400 * 2,
          progress: 30
        }
      ],
      total: 2,
      page: params.page || 1,
      size: params.size || 20
    }),
    getProjectDetail: (id) => {
      console.log('[备用模拟数据服务] 获取项目详情, ID:', id);
      return {
        code: 0,
        msg: 'ok',
        data: {
          _id: id || 'mock1',
          model: '模拟项目详情' + (id ? ` #${id}` : ''),
          status: 2,
          devManager: '王工',
          bizManager: '张经理',
          cate: '研发项目',
          createTime: Math.floor(Date.now() / 1000) - 86400,
          updateTime: Math.floor(Date.now() / 1000),
          progress: 20,
          description: '这是一个模拟项目，用于离线数据展示。该项目包含完整的项目周期和文档。',
          priority: 'high',
          
          // 项目参数字段
          WORK_TEMP: '-20~60',
          CERTIFICATION: 'CE',
          LOW_POWER: '18',
          STARTUP_TIME: '0.8',
          CONFORMAL_COATING: '标准',
          RATED_VOLTAGE: '5',
          MAX_POWER: '0.5',
          MAX_SPEED: '4500',
          POLE_PAIRS: '16',
          HAS_HALL: '双霍尔',
          CONTROL_MODE: '开环控制',
          CONTROL_ALGORITHM: 'PI',
          
          // 保护参数
          STALL_PROTECTION: '支持',
          OVERVOLTAGE_PROTECTION: '6.5V',
          UNDERVOLTAGE_PROTECTION: '4.2V',
          TEMPERATURE_PROTECTION: '75℃',
          OVERCURRENT_PROTECTION: '120A',
          
          // 控制接口参数
          CONTROL_INTERFACE: '开环控制',
          
          // 项目类型
          PROJECT_TYPE_NAME: '电流传感器'
        }
      };
    }
  };
}

// 加载缓存服务（用于优化离线体验）
let cacheService;
try {
  // 使用统一配置入口模式引入缓存助手
  try {
    const { cacheHelper } = require('../config/project_helpers_config');
    console.log('成功加载缓存助手');
    
    // 创建简单的PLM项目缓存服务
    cacheService = {
      PROJECT_LIST_KEY: 'plm_project_list_cache',
      PROJECT_DETAIL_PREFIX: 'plm_project_detail_',
      
      saveProjectList: (data, params = {}) => {
        const cacheKey = `${cacheService.PROJECT_LIST_KEY}_${JSON.stringify(params)}`;
        cacheHelper.set(cacheKey, data, 3600); // 缓存1小时
      },
      
      getProjectList: (params = {}) => {
        const cacheKey = `${cacheService.PROJECT_LIST_KEY}_${JSON.stringify(params)}`;
        return cacheHelper.get(cacheKey);
      },
      
      saveProjectDetail: (id, data) => {
        const cacheKey = `${cacheService.PROJECT_DETAIL_PREFIX}${id}`;
        cacheHelper.set(cacheKey, data, 3600); // 缓存1小时
      },
      
      getProjectDetail: (id) => {
        const cacheKey = `${cacheService.PROJECT_DETAIL_PREFIX}${id}`;
        return cacheHelper.get(cacheKey);
      },
      
      clearAllCache: () => {
        // 清除所有PLM项目相关缓存
        const keys = cacheHelper.getAllKeys();
        for (let key of keys) {
          if (key.startsWith(cacheService.PROJECT_LIST_KEY) || 
              key.startsWith(cacheService.PROJECT_DETAIL_PREFIX)) {
            cacheHelper.remove(key);
          }
        }
      },
      
      // 添加remove方法
      remove: (key) => {
        if (!key) return;
        try {
          cacheHelper.remove(key);
          console.log('缓存服务] 成功移除项目详情缓存, ID:', key);
        } catch (e) {
          console.warn('[缓存服务] 移除项目详情缓存失败:', e);
        }
      }
    };
  } catch (cacheHelperError) {
    console.error('加载缓存助手失败，提供空实现', cacheHelperError);
    cacheService = {
      saveProjectList: () => {},
      getProjectList: () => null,
      saveProjectDetail: () => {},
      getProjectDetail: () => null,
      clearAllCache: () => {},
      remove: () => {}
    };
  }
  
  console.log('成功创建PLM项目缓存服务');
} catch (e) {
  console.error('创建PLM项目缓存服务失败，将不使用缓存', e);
  // 提供空实现
  cacheService = {
    saveProjectList: () => {},
    getProjectList: () => null,
    saveProjectDetail: () => {},
    getProjectDetail: () => null,
    clearAllCache: () => {},
    remove: () => {}
  };
}

// 创建安全包装器
const plmProjectStoreWrapper = {
  // 保留原始Store的所有属性和方法
  ...originalStore,
  
  // 包装异步方法，确保状态更新在action中执行
  getProjectList: mobxTools.createSafeAction(async function(params = {}) {
    try {
      // 安全设置loading状态
      mobxTools.safeSet(originalStore, 'loading', true);
      mobxTools.safeSet(originalStore, 'error', null);
      
      const options = {
        title: '加载中...',
        hasLoading: true
      };
      
      // 尝试使用缓存数据（如果可用）
      const cachedData = cacheService.getProjectList(params);
      if (cachedData && !params.forceRefresh) {
        console.log('使用缓存的项目列表数据');
        
        // 确保缓存数据有效
        if (!cachedData.list || !Array.isArray(cachedData.list)) {
          console.warn('缓存的项目列表数据无效，尝试刷新数据');
          throw new Error('缓存数据结构异常');
        }
        
        // 安全更新项目列表（使用缓存数据）
        if (params.page === 1 || !params.page) {
          // 第一页，替换数据
          mobxTools.safeSet(originalStore, 'projectList', 
            cachedData.list.map(item => originalStore.formatProject(item))
          );
        } else {
          // 分页加载，追加数据
          mobxTools.safeSet(originalStore, 'projectList', 
            [...originalStore.projectList, ...cachedData.list.map(item => originalStore.formatProject(item))]
          );
        }
        
        // 安全更新分页信息
        mobxTools.safeSet(originalStore, 'pagination', {
          page: params.page || 1,
          size: params.size || 20,
          total: cachedData.total || 0,
          hasMore: originalStore.projectList.length < (cachedData.total || 0)
        });
        
        // 完成后设置loading状态
        mobxTools.safeSet(originalStore, 'loading', false);
        
        // 在后台异步刷新缓存数据
        this._refreshCacheInBackground(params);
        
        return cachedData;
      }
      
      // 使用pageHelper自己的callCloudData方法，不要重新定义CloudHelper
      
      // 准备请求参数
      const requestParams = {
        page: params.page || 1,
        size: params.size || 20,
        ...originalStore.filters,
        ...params
      };
      
      try {
        // 尝试从服务器获取数据
        const result = await pageHelper.callCloudData('mcloud', {
          route: 'project_list',
          ...requestParams,
          PID: 'plm'
        }, options);
        
        // 安全检查结果
        if (!result || !result.list || !Array.isArray(result.list)) {
          console.warn('服务器返回的项目列表结构异常:', result);
          throw new Error('服务器返回的数据结构异常');
        }
        
        // 安全更新项目列表
        if (params.page === 1 || !params.page) {
          // 第一页，替换数据
          mobxTools.safeSet(originalStore, 'projectList', 
            result.list.map(item => originalStore.formatProject(item))
          );
        } else {
          // 分页加载，追加数据
          mobxTools.safeSet(originalStore, 'projectList', 
            [...originalStore.projectList, ...result.list.map(item => originalStore.formatProject(item))]
          );
        }
        
        // 安全更新分页信息
        mobxTools.safeSet(originalStore, 'pagination', {
          page: params.page || 1,
          size: params.size || 20,
          total: result.total || 0,
          hasMore: originalStore.projectList.length < (result.total || 0)
        });
        
        // 缓存结果
        cacheService.saveProjectList(result, params);
        
        // 完成后设置loading状态
        mobxTools.safeSet(originalStore, 'loading', false);
        
        return result;
      } catch (serverError) {
        console.error('从服务器获取项目列表失败，尝试使用模拟数据:', serverError);
        
        // 使用模拟数据服务
        let mockResult = mockService.getProjectList(requestParams);
        
        // 确保模拟数据结构完整
        if (!mockResult || !mockResult.list || !Array.isArray(mockResult.list)) {
          console.warn('模拟数据结构异常，创建默认数据结构');
          mockResult = {
            list: [],
            total: 0,
            page: params.page || 1,
            size: params.size || 20,
            code: 0,
            msg: 'default mock data'
          };
        }
        
        // 安全更新项目列表（使用模拟数据）
        if (params.page === 1 || !params.page) {
          // 第一页，替换数据
          mobxTools.safeSet(originalStore, 'projectList', 
            mockResult.list.map(item => originalStore.formatProject(item))
          );
        } else {
          // 分页加载，追加数据
          mobxTools.safeSet(originalStore, 'projectList', 
            [...originalStore.projectList, ...mockResult.list.map(item => originalStore.formatProject(item))]
          );
        }
        
        // 安全更新分页信息
        mobxTools.safeSet(originalStore, 'pagination', {
          page: params.page || 1,
          size: params.size || 20,
          total: mockResult.total || 0,
          hasMore: originalStore.projectList.length < (mockResult.total || 0)
        });
        
        // 完成后设置loading状态
        mobxTools.safeSet(originalStore, 'loading', false);
        
        // 缓存模拟结果
        cacheService.saveProjectList(mockResult, params);
        
        return mockResult;
      }
    } catch (error) {
      // 错误处理
      console.error('加载项目列表完全失败', error);
      mobxTools.safeSet(originalStore, 'error', error);
      mobxTools.safeSet(originalStore, 'loading', false);
      
      // 加载错误助手
      try {
        // 修复: 使用预定义的errorHandler
        errorHandler.handleMobxError(error, 'getProjectList');
        
        // 尝试从缓存中恢复数据
        const cachedData = cacheService.getProjectList(params);
        if (cachedData && cachedData.list && Array.isArray(cachedData.list)) {
          // 使用缓存数据恢复
          console.log('从缓存恢复项目列表数据');
          
          // 安全更新项目列表（使用缓存数据）
          mobxTools.safeSet(originalStore, 'projectList', 
            cachedData.list.map(item => originalStore.formatProject(item))
          );
          
          // 安全更新分页信息
          mobxTools.safeSet(originalStore, 'pagination', {
            page: params.page || 1,
            size: params.size || 20,
            total: cachedData.total || 0,
            hasMore: false // 出错时禁用加载更多
          });
          
          return cachedData;
        }
      } catch (e) {
        console.error('加载错误助手失败', e);
      }
      
      throw error;
    }
  }, 'getProjectList'),
  
  // 后台刷新缓存数据的辅助方法
  _refreshCacheInBackground: async function(params) {
    try {
      // 修复: 使用预定义的CloudHelper
      const CloudHelper = pageHelper;
      
      // 准备请求参数
      const requestParams = {
        page: params.page || 1,
        size: params.size || 20,
        ...originalStore.filters,
        ...params
      };
      
      // 静默获取数据（无加载提示）
      const result = await CloudHelper.callCloudData('mcloud', {
        route: 'project_list',
        ...requestParams,
        PID: 'plm'
      }, {
        title: '', // 无标题
        hasLoading: false // 不显示加载状态
      });
      
      // 更新缓存
      if (result && result.code === 0) {
        cacheService.saveProjectList(result, params);
        console.log('后台成功刷新项目列表缓存');
      }
    } catch (error) {
      // 静默失败，不影响用户体验
      console.warn('后台刷新缓存失败，继续使用现有数据', error);
    }
  },
  
  // 包装更多项目加载方法
  loadMoreProjects: mobxTools.createSafeAction(async function() {
    if (!originalStore.pagination.hasMore || originalStore.loading) return;
    
    const nextPage = originalStore.pagination.page + 1;
    return this.getProjectList({ page: nextPage });
  }, 'loadMoreProjects'),
  
  // 包装过滤器设置方法
  setFilters: mobxTools.createSafeAction(function(filters) {
    mobxTools.safeSet(originalStore, 'filters', {
      ...originalStore.filters,
      ...filters
    });
    
    // 重置分页
    mobxTools.safeSet(originalStore, 'pagination', {
      ...originalStore.pagination,
      page: 1
    });
  }, 'setFilters'),
  
  // 包装缓存清理方法
  clearAllCache: mobxTools.createSafeAction(function() {
    mobxTools.safeSet(originalStore, 'projectList', []);
    mobxTools.safeSet(originalStore, 'pagination', { 
      page: 1, 
      size: 20, 
      total: 0, 
      hasMore: true 
    });
    mobxTools.safeSet(originalStore, 'error', null);
    
    // 清除缓存
    cacheService.clearAllCache();
  }, 'clearAllCache'),
  
  // 包装项目详情获取方法
  getProjectDetail: mobxTools.createSafeAction(async function(id) {
    if (!id) {
      throw new Error('项目ID不能为空');
    }
    
    console.log('[PLM项目] 开始加载项目详情, ID:', id);
    mobxTools.safeSet(originalStore, 'loading', true);
    mobxTools.safeSet(originalStore, 'error', null);
    
    try {
      // 如果是mock003项目，直接使用模拟数据而不使用缓存
      if (id === 'mock003') {
        console.log('[PLM项目] 检测到mock003项目，跳过缓存直接获取最新模拟数据');
        
        // 使用模拟数据服务
        let mockResult = mockService.getProjectDetail(id);
        
        // 确保模拟数据结构完整
        if (!mockResult || !mockResult.data) {
          console.warn('[PLM项目] mock003模拟数据结构异常');
          throw new Error('获取mock003项目详情失败');
        }
        
        console.log('[PLM项目] 成功获取mock003模拟数据:', mockResult.data.model);
        
        // 格式化项目数据（确保绑定this上下文）
        const project = originalStore.formatProject.call(originalStore, mockResult.data);
        
        // 更新缓存
        cacheService.saveProjectDetail(id, mockResult.data);
        
        mobxTools.safeSet(originalStore, 'loading', false);
        
        return project;
      }
      
      // 非mock003项目尝试使用缓存数据
      const cachedDetail = cacheService.getProjectDetail(id);
      if (cachedDetail && !cachedDetail.forceRefresh) {
        console.log('[PLM项目] 使用缓存的项目详情数据');
        
        // 验证缓存数据
        if (!cachedDetail) {
          console.warn('[PLM项目] 缓存数据无效，尝试刷新数据');
          throw new Error('缓存数据结构异常');
        }
        
        // 格式化项目数据（确保绑定this上下文）
        const project = originalStore.formatProject.call(originalStore, cachedDetail);
        console.log('[PLM项目] 缓存项目数据格式化完成:', project.model);
        
        // 完成后设置loading状态
        mobxTools.safeSet(originalStore, 'loading', false);
        
        // 在后台异步刷新缓存
        this._refreshDetailCacheInBackground(id);
        
        return project;
      }
      
      // 显示加载提示
      const options = {
        title: '加载中...',
        hasLoading: true
      };
      
      console.log('[PLM项目] 尝试从服务器获取项目详情');
      try {
        // 修复: 使用预定义的CloudHelper
        const CloudHelper = pageHelper;
        
        // 尝试从服务器获取数据
        const result = await CloudHelper.callCloudData('mcloud', {
          route: 'project_detail',
          id,
          PID: 'plm'
        }, options);
        
        if (!result || !result.data) {
          console.warn('[PLM项目] 服务器返回的项目详情结构异常:', result);
          throw new Error('获取项目详情失败');
        }
        
        console.log('[PLM项目] 成功获取项目详情:', result.data.model || '未命名项目');
        
        // 格式化项目数据（确保绑定this上下文）
        const project = originalStore.formatProject.call(originalStore, result.data);
        
        // 缓存结果
        cacheService.saveProjectDetail(id, result.data);
        
        mobxTools.safeSet(originalStore, 'loading', false);
        
        return project;
      } catch (serverError) {
        console.error('[PLM项目] 从服务器获取项目详情失败，尝试使用模拟数据:', serverError);
        
        // 使用模拟数据服务
        console.log('[PLM项目] 调用模拟数据服务getProjectDetail, ID:', id);
        let mockResult = mockService.getProjectDetail(id);
        
        // 确保模拟数据结构完整
        if (!mockResult || !mockResult.data) {
          console.warn('[PLM项目] 模拟数据结构异常，创建默认数据结构');
          mockResult = {
            code: 0,
            msg: 'default mock data',
            data: {
              _id: id || 'mock_' + Date.now(),
              model: `默认模拟项目 ${id || ''}`,
              status: 2,
              cate: '默认分类',
              devManager: '默认负责人',
              createTime: Math.floor(Date.now() / 1000) - 86400,
              updateTime: Math.floor(Date.now() / 1000),
              description: '这是一个默认的模拟项目，因为获取真实数据失败而创建。',
              progress: 20
            }
          };
        }
        
        console.log('[PLM项目] 成功获取模拟项目数据:', mockResult.data.model);
        
        // 格式化项目数据（确保绑定this上下文）
        const project = originalStore.formatProject.call(originalStore, mockResult.data);
        
        // 缓存模拟结果
        cacheService.saveProjectDetail(id, mockResult.data);
        
        mobxTools.safeSet(originalStore, 'loading', false);
        
        return project;
      }
    } catch (error) {
      console.error('[PLM项目] 加载项目详情完全失败:', error);
      mobxTools.safeSet(originalStore, 'error', error);
      mobxTools.safeSet(originalStore, 'loading', false);
      
      // 加载错误助手
      try {
        // 修复: 使用预定义的errorHandler
        errorHandler.handleMobxError(error, 'getProjectDetail');
        
        // 尝试从缓存中恢复数据
        const cachedDetail = cacheService.getProjectDetail(id);
        if (cachedDetail) {
          console.log('[PLM项目] 尝试从缓存恢复项目详情数据');
          return originalStore.formatProject.call(originalStore, cachedDetail);
        } else {
          console.log('[PLM项目] 没有缓存数据可恢复，尝试创建应急模拟数据');
          // 创建一个应急的模拟项目数据
          const emergencyProject = {
            _id: id || 'emergency_' + Date.now(),
            model: `应急项目数据 ${id || ''}`,
            status: 2,
            cate: '未知分类',
            devManager: '未知',
            bizManager: '未知',
            createTime: Math.floor(Date.now() / 1000) - 86400,
            updateTime: Math.floor(Date.now() / 1000),
            description: '这是一个应急创建的项目数据，所有数据获取渠道都失败时使用。',
            progress: 0
          };
          return originalStore.formatProject.call(originalStore, emergencyProject);
        }
      } catch (e) {
        console.error('[PLM项目] 错误恢复失败，抛出原始错误:', e);
      }
      
      throw error;
    }
  }, 'getProjectDetail'),
  
  // 后台刷新详情缓存的辅助方法
  _refreshDetailCacheInBackground: async function(id) {
    try {
      // 修复: 使用预定义的CloudHelper
      const CloudHelper = pageHelper;
      
      // 静默获取数据（无加载提示）
      const result = await CloudHelper.callCloudData('mcloud', {
        route: 'project_detail',
        id,
        PID: 'plm'
      }, {
        title: '', // 无标题
        hasLoading: false // 不显示加载状态
      });
      
      // 更新缓存
      if (result && result.code === 0 && result.data) {
        cacheService.saveProjectDetail(id, result.data);
        console.log('后台成功刷新项目详情缓存');
      }
    } catch (error) {
      // 静默失败，不影响用户体验
      console.warn('后台刷新详情缓存失败，继续使用现有数据', error);
    }
  }
};

// 导出包装后的Store
module.exports = plmProjectStoreWrapper;

// 添加缓存服务访问方法
plmProjectStoreWrapper._getCacheService = {
  removeProjectDetail: function(id) {
    if (!id) return;
    
    try {
      // 不直接调用cacheService.remove，而是使用更安全的方法
      const cacheKey = `plm_project_detail_${id}`;
      try {
        // 尝试使用cacheHelper
        const { cacheHelper } = require('../config/project_helpers_config');
        if (cacheHelper && cacheHelper.remove) {
          cacheHelper.remove(cacheKey);
          console.log('[缓存服务] 成功移除项目详情缓存, ID:', id);
          return true;
        }
      } catch (e1) {
        // 尝试使用pageHelper
        if (pageHelper && pageHelper.remove) {
          pageHelper.remove(cacheKey);
          console.log('[缓存服务] 使用pageHelper成功移除项目详情缓存, ID:', id);
          return true;
        }
      }
      console.warn('[缓存服务] 未找到可用的缓存移除方法');
      return false;
    } catch (e) {
      console.warn('[缓存服务] 移除项目详情缓存失败:', e);
      return false;
    }
  }
}; 